{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "8652289482483ed5",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "# 人名分类器"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "76466cfe3245c01f",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "以一个人名为输入, 使用模型帮助我们判断它最有可能是来自哪一个国家的人名"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0a98c6e8c08fd6f",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 1. 导入相关包"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.575750300Z",
     "start_time": "2025-10-31T14:10:40.295156400Z"
    }
   },
   "outputs": [],
   "source": [
    "import string\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from tqdm import tqdm\n",
    "import time\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dbcb826fbffcaff0",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 2. 数据处理"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a69f66f5b0da2eca",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.580937400Z",
     "start_time": "2025-10-31T14:10:41.575750300Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "n_letter: 57\n"
     ]
    }
   ],
   "source": [
    "# 获取所有常用字符包括字母和常用标点\n",
    "all_letters = string.ascii_letters + \" .,;'\"  # 词表大小\n",
    "\n",
    "# 获取常用字符数量\n",
    "n_letters = len(all_letters)\n",
    "print(\"n_letter:\", n_letters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "35176396474f8776",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.586065700Z",
     "start_time": "2025-10-31T14:10:41.580937400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "categorys_num:  18\n"
     ]
    }
   ],
   "source": [
    "#  国家名\n",
    "categorys = ['Italian', 'English', 'Arabic', 'Spanish', 'Scottish', 'Irish', 'Chinese', 'Vietnamese', 'Japanese',\n",
    "             'French', 'Greek', 'Dutch', 'Korean', 'Polish', 'Portuguese', 'Russian', 'Czech', 'German']\n",
    "\n",
    "# 国家名数量\n",
    "categorys_num = len(categorys)\n",
    "print('categorys_num: ', categorys_num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c8b4d88dee09c6b",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.590917900Z",
     "start_time": "2025-10-31T14:10:41.586065700Z"
    }
   },
   "outputs": [],
   "source": [
    "# 读取数据\n",
    "def ReadData(filename):\n",
    "    my_list_x = []\n",
    "    my_list_y = []\n",
    "    with open(file=filename, mode='r', encoding='utf-8') as f:\n",
    "        for line in f.readlines():  # 按照行读数据\n",
    "            if len(line) < 5:\n",
    "                continue\n",
    "            x, y = line.strip().split('\\t')\n",
    "            my_list_x.append(x)\n",
    "            my_list_y.append(y)\n",
    "        return my_list_x, my_list_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "542857cc4403f9d2",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.603763600Z",
     "start_time": "2025-10-31T14:10:41.588594400Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "数据总数：20074\n"
     ]
    }
   ],
   "source": [
    "# 读取数据\n",
    "filename = './data/name_classfication.txt'\n",
    "my_list_x, my_list_y = ReadData(filename)\n",
    "print(f'数据总数：{len(my_list_x)}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "b613e42349e659cd",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.604947300Z",
     "start_time": "2025-10-31T14:10:41.602678700Z"
    }
   },
   "outputs": [],
   "source": [
    "# 构建数据集\n",
    "class NameClassDataset(Dataset):  # 自己构建数据集需要继承Dataset类\n",
    "    def __init__(self, my_list_x, my_list_y):\n",
    "        self.my_list_x = my_list_x  # 样本x\n",
    "        self.my_list_y = my_list_y  # 样本y\n",
    "\n",
    "    def __len__(self):  # 重写__len()__方法\n",
    "        return len(self.my_list_x)\n",
    "\n",
    "    def __getitem__(self, index):  # 重写__getitem__方法\n",
    "        # 对index异常值进行修正 [0, len-1]\n",
    "        index = min(max(0, index), len(self.my_list_x) - 1)\n",
    "\n",
    "        # 按索引获取 数据样本 x y\n",
    "        x = self.my_list_x[index]\n",
    "        y = self.my_list_y[index]\n",
    "\n",
    "        # 样本x one-hot张量化\n",
    "        tensor_x = torch.zeros(len(x), n_letters)\n",
    "        for idx, letter in enumerate(x):\n",
    "            tensor_x[idx][all_letters.find(letter)] = 1\n",
    "\n",
    "        # 样本y 张量化\n",
    "        tensor_y = torch.tensor(categorys.index(y), dtype=torch.long)\n",
    "        return tensor_x, tensor_y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "574715dd0ad804db",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.635943600Z",
     "start_time": "2025-10-31T14:10:41.605959Z"
    }
   },
   "outputs": [],
   "source": [
    "# 构建迭代器遍历数据\n",
    "name_class_dataset = NameClassDataset(my_list_x, my_list_y)\n",
    "\n",
    "# 数据维度：[人名长度, 57]\n",
    "name_class_dataload = DataLoader(dataset=name_class_dataset, batch_size=1, shuffle=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ace8843a9f46fb9e",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 3. 构建模型"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e1cd8d760597dc46",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "### 构建RNN模型"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "47c115b522b2794",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.635943600Z",
     "start_time": "2025-10-31T14:10:41.610846400Z"
    }
   },
   "outputs": [],
   "source": [
    "class MyRnn(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, num_layers=1):\n",
    "        super().__init__()\n",
    "\n",
    "        self.input_size = input_size  # 输入维度\n",
    "        self.hidden_size = hidden_size  # 隐藏层维度\n",
    "        self.output_size = output_size  # 输出维度\n",
    "        self.num_layers = num_layers  # 隐藏层层数\n",
    "\n",
    "        # 定义RNN层\n",
    "        self.rnn = nn.RNN(self.input_size, self.hidden_size, num_layers, batch_first=True)\n",
    "\n",
    "        # 定义linear层\n",
    "        self.linear = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "        # 定义softmax层\n",
    "        self.softmax = nn.LogSoftmax(dim=-1)\n",
    "\n",
    "    # 定义前向传播\n",
    "    def forward(self, input):\n",
    "        _, output = self.rnn(input)\n",
    "        output = self.linear(output)  # 通过线性层\n",
    "        output = self.softmax(output)  # 经过激活函数进行18分类\n",
    "\n",
    "        # 返回分类结果\n",
    "        return output"
   ]
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 构建LSTM模型"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9667cc85d8a3a3e5"
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [],
   "source": [
    "# LSTM\n",
    "class MyLSTM(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, num_layers=1):\n",
    "        super().__init__()\n",
    "\n",
    "        self.input_size = input_size  # 输入维度\n",
    "        self.hidden_size = hidden_size  # 隐藏层维度\n",
    "        self.output_size = output_size  # 输出维度\n",
    "        self.num_layers = num_layers  # 隐藏层层数\n",
    "\n",
    "        # 定义RNN层\n",
    "        self.lstm = nn.LSTM(self.input_size, self.hidden_size, num_layers, batch_first=True)\n",
    "\n",
    "        # 定义linear层\n",
    "        self.linear = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "        # 定义softmax层\n",
    "        self.softmax = nn.LogSoftmax(dim=-1)\n",
    "\n",
    "    # 定义前向传播\n",
    "    def forward(self, input):\n",
    "        _, (output, _) = self.lstm(input)\n",
    "        output = self.linear(output)  # 通过线性层\n",
    "        output = self.softmax(output)  # 经过激活函数进行18分类\n",
    "\n",
    "        # 返回分类结果\n",
    "        return output"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.635943600Z",
     "start_time": "2025-10-31T14:10:41.615154800Z"
    }
   },
   "id": "db664463251f8fef"
  },
  {
   "cell_type": "markdown",
   "source": [
    "### 构建GRU模型"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "fda4ff0cc3f16a47"
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "outputs": [],
   "source": [
    "class MyGRU(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size, num_layers=1):\n",
    "        super().__init__()\n",
    "\n",
    "        self.input_size = input_size  # 输入维度\n",
    "        self.hidden_size = hidden_size  # 隐藏层维度\n",
    "        self.output_size = output_size  # 输出维度\n",
    "        self.num_layers = num_layers  # 隐藏层层数\n",
    "\n",
    "        # 定义GRU层\n",
    "        self.gru = nn.GRU(self.input_size, self.hidden_size, num_layers, batch_first=True)\n",
    "\n",
    "        # 定义linear层\n",
    "        self.linear = nn.Linear(self.hidden_size, self.output_size)\n",
    "\n",
    "        # 定义softmax层\n",
    "        self.softmax = nn.LogSoftmax(dim=-1)\n",
    "\n",
    "    # 定义前向传播\n",
    "    def forward(self, input):\n",
    "        _, output = self.gru(input)\n",
    "        output = self.linear(output)  # 通过线性层\n",
    "        output = self.softmax(output)  # 经过激活函数进行18分类\n",
    "\n",
    "        # 返回分类结果\n",
    "        return output"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.637077300Z",
     "start_time": "2025-10-31T14:10:41.618557600Z"
    }
   },
   "id": "cb3281263844445d"
  },
  {
   "cell_type": "markdown",
   "id": "f33534eae43ec2b",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## 4. 模型训练"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "736c8171eb166193",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T12:51:47.382359100Z",
     "start_time": "2025-10-31T12:51:42.218450500Z"
    },
    "collapsed": false
   },
   "source": [
    "### RNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "53ded41edf713e94",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.637077300Z",
     "start_time": "2025-10-31T14:10:41.623525600Z"
    }
   },
   "outputs": [],
   "source": [
    "# 模型训练参数\n",
    "lr = 1e-3  # 学习率\n",
    "epochs = 8  # 轮次\n",
    "n_hidden = 128  # 隐藏层维度"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "b6739e45",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.637077300Z",
     "start_time": "2025-10-31T14:10:41.627295600Z"
    }
   },
   "outputs": [],
   "source": [
    "total_loss_list_rnn = []  # rnn损失列表\n",
    "total_loss_list_lstm = []  # lstm损失列表\n",
    "total_loss_list_gru = []  # gru损失列表\n",
    "total_acc_list_rnn = []  # rnn准确率列表\n",
    "total_acc_list_lstm = []  # lstm准确率列表\n",
    "total_acc_list_gru = []  # gru准确率列表\n",
    "rnn_total_time = 0.0  # rnn每轮训练时间\n",
    "lstm_total_time = 0.0  # lstm每轮训练时间\n",
    "gru_total_time = 0.0  # gru每轮训练时间"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fea3916582845e6",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:10:41.637077300Z",
     "start_time": "2025-10-31T14:10:41.633308100Z"
    }
   },
   "outputs": [],
   "source": [
    "# RNN\n",
    "def MyRnnTrain():\n",
    "    # 统计总的训练时间\n",
    "    global rnn_total_time\n",
    "\n",
    "    # 实例化模型\n",
    "    my_rnn = MyRnn(n_letters, n_hidden, categorys_num)\n",
    "\n",
    "    # 构建损失函数\n",
    "    mycrossentropyloss = nn.NLLLoss()\n",
    "\n",
    "    # 构建优化器\n",
    "    myadam = optim.Adam(my_rnn.parameters(), lr=lr)\n",
    "\n",
    "    # 定义训练参数\n",
    "    total_iter_num = 0  # 迭代次数，已训练样本数\n",
    "\n",
    "    total_loss = 0.0  # 已训练的损失和\n",
    "\n",
    "    total_acc_num = 0  # 已训练样本准确总数\n",
    "\n",
    "    for epoch_idx in range(epochs):\n",
    "        start_time = time.time()  # 开始训练时间\n",
    "        for idx, (x, y) in tqdm(enumerate(name_class_dataload), total=len(name_class_dataload),\n",
    "                                desc=f'Epoch {epoch_idx + 1}/{epochs}'):\n",
    "            # 模型训练\n",
    "            output_n = my_rnn(x)  # DataLoader会自动添加批次数\n",
    "            output = output_n[-1]\n",
    "\n",
    "            # 计算损失\n",
    "            myloss = mycrossentropyloss(output, y)\n",
    "\n",
    "            # 梯度清零\n",
    "            myadam.zero_grad()\n",
    "\n",
    "            # 反向传播\n",
    "            myloss.backward()\n",
    "\n",
    "            # 更新参数\n",
    "            myadam.step()\n",
    "\n",
    "            # 计算损失\n",
    "            total_iter_num += 1\n",
    "            total_loss += myloss\n",
    "\n",
    "            # 计算准确率\n",
    "            predit_tag = 1 if torch.argmax(output).item() == y.item() else 0\n",
    "            total_acc_num += predit_tag\n",
    "\n",
    "            # 每200批次求一次平均损失和平均准确率\n",
    "            if (idx + 1) % 200 == 0:\n",
    "                avg_loss = total_loss / total_iter_num\n",
    "                total_loss_list_rnn.append(avg_loss.item())\n",
    "                avg_acc = total_acc_num / total_iter_num\n",
    "                total_acc_list_rnn.append(avg_acc)\n",
    "\n",
    "        end_time = time.time()\n",
    "        epoch_time = end_time - start_time\n",
    "        rnn_total_time += epoch_time\n",
    "        print(f'Epoch {epoch_idx + 1}/{epochs}, 损失:{avg_loss:.4f}, 准确率:{avg_acc:.4f}, 时间: {epoch_time:.2f}s')\n",
    "\n",
    "    # 保存模型\n",
    "    torch.save(my_rnn.state_dict(), './model/my_rnn_model.bin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8aaec05aa4ed6fa9",
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:15:17.127058800Z",
     "start_time": "2025-10-31T14:10:41.637077300Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/8: 100%|██████████| 20074/20074 [00:34<00:00, 581.55it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8, 损失:1.1269, 准确率:0.6660, 时间: 34.52s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/8: 100%|██████████| 20074/20074 [00:33<00:00, 596.36it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/8, 损失:1.0313, 准确率:0.6914, 时间: 33.66s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/8: 100%|██████████| 20074/20074 [00:34<00:00, 584.48it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/8, 损失:0.9726, 准确率:0.7080, 时间: 34.35s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/8: 100%|██████████| 20074/20074 [00:34<00:00, 590.19it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/8, 损失:0.9329, 准确率:0.7192, 时间: 34.01s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/8: 100%|██████████| 20074/20074 [00:33<00:00, 596.78it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/8, 损失:0.9061, 准确率:0.7271, 时间: 33.64s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/8: 100%|██████████| 20074/20074 [00:34<00:00, 590.22it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/8, 损失:0.8875, 准确率:0.7324, 时间: 34.01s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/8: 100%|██████████| 20074/20074 [00:33<00:00, 592.58it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/8, 损失:0.8737, 准确率:0.7364, 时间: 33.88s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/8: 100%|██████████| 20074/20074 [00:34<00:00, 590.34it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/8, 损失:0.8634, 准确率:0.7396, 时间: 34.01s\n"
     ]
    }
   ],
   "source": [
    "MyRnnTrain()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b10f8e33",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T12:51:47.382359100Z",
     "start_time": "2025-10-31T12:51:42.241525200Z"
    }
   },
   "source": [
    "### LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "11dd39ad",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:15:17.136343300Z",
     "start_time": "2025-10-31T14:15:17.130886Z"
    }
   },
   "outputs": [],
   "source": [
    "# LSTM\n",
    "def MyLSTMTrain():\n",
    "    # 统计总的训练时间\n",
    "    global lstm_total_time\n",
    "\n",
    "    # 实例化模型\n",
    "    my_lstm = MyLSTM(n_letters, n_hidden, categorys_num)\n",
    "\n",
    "    # 构建损失函数\n",
    "    mycrossentropyloss = nn.NLLLoss()\n",
    "\n",
    "    # 构建优化器\n",
    "    myadam = optim.Adam(my_lstm.parameters(), lr=lr)\n",
    "\n",
    "    # 定义训练参数\n",
    "    total_iter_num = 0  # 迭代次数，已训练样本数\n",
    "    total_loss = 0.0  # 已训练的损失和\n",
    "    total_acc_num = 0  # 已训练样本准确总数\n",
    "\n",
    "    for epoch_idx in range(epochs):\n",
    "        start_time = time.time()  # 开始训练时间\n",
    "        for idx, (x, y) in tqdm(enumerate(name_class_dataload), total=len(name_class_dataload),\n",
    "                                desc=f'Epoch {epoch_idx + 1}/{epochs}'):\n",
    "            # 模型训练\n",
    "            output_n = my_lstm(x)  # DataLoader会自动添加批次数\n",
    "            output = output_n[-1]\n",
    "\n",
    "            # 计算损失\n",
    "            myloss = mycrossentropyloss(output, y)\n",
    "\n",
    "            # 梯度清零\n",
    "            myadam.zero_grad()\n",
    "\n",
    "            # 反向传播\n",
    "            myloss.backward()\n",
    "\n",
    "            # 更新参数\n",
    "            myadam.step()\n",
    "\n",
    "            # 计算损失\n",
    "            total_iter_num += 1\n",
    "            total_loss += myloss\n",
    "\n",
    "            # 计算准确率\n",
    "            predit_tag = 1 if torch.argmax(output).item() == y.item() else 0\n",
    "            total_acc_num += predit_tag\n",
    "\n",
    "            # 每200批次求一次平均损失和平均准确率\n",
    "            if (idx + 1) % 200 == 0:\n",
    "                avg_loss = total_loss / total_iter_num\n",
    "                total_loss_list_lstm.append(avg_loss.item())\n",
    "                avg_acc = total_acc_num / total_iter_num\n",
    "                total_acc_list_lstm.append(avg_acc)\n",
    "\n",
    "        end_time = time.time()\n",
    "        epoch_time = end_time - start_time\n",
    "        lstm_total_time += epoch_time\n",
    "        print(f'Epoch {epoch_idx + 1}/{epochs}, 损失:{avg_loss:.4f}, 准确率:{avg_acc:.4f}, 时间: {epoch_time:.2f}s')\n",
    "\n",
    "    # 保存模型\n",
    "    torch.save(my_lstm.state_dict(), './model/my_lstm_model.bin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/8: 100%|██████████| 20074/20074 [00:49<00:00, 405.53it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8, 损失:1.0263, 准确率:0.6953, 时间: 49.50s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/8: 100%|██████████| 20074/20074 [00:50<00:00, 399.22it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/8, 损失:0.8506, 准确率:0.7442, 时间: 50.28s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/8: 100%|██████████| 20074/20074 [00:50<00:00, 397.85it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/8, 损失:0.7476, 准确率:0.7724, 时间: 50.46s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/8: 100%|██████████| 20074/20074 [01:12<00:00, 275.91it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/8, 损失:0.6755, 准确率:0.7920, 时间: 72.76s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/8: 100%|██████████| 20074/20074 [01:21<00:00, 247.25it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/8, 损失:0.6183, 准确率:0.8083, 时间: 81.19s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/8: 100%|██████████| 20074/20074 [00:56<00:00, 354.64it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/8, 损失:0.5706, 准确率:0.8220, 时间: 56.60s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/8: 100%|██████████| 20074/20074 [00:51<00:00, 386.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/8, 损失:0.5301, 准确率:0.8337, 时间: 52.00s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/8: 100%|██████████| 20074/20074 [00:52<00:00, 385.59it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/8, 损失:0.4950, 准确率:0.8441, 时间: 52.06s\n"
     ]
    }
   ],
   "source": [
    "MyLSTMTrain()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:23:02.738069800Z",
     "start_time": "2025-10-31T14:15:17.134795400Z"
    }
   },
   "id": "4e03c16779347e76"
  },
  {
   "cell_type": "markdown",
   "id": "98b06cfd",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T12:24:56.562761700Z",
     "start_time": "2025-10-31T12:24:56.553198400Z"
    }
   },
   "source": [
    "### GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "1c7ba7ce",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:23:02.746593600Z",
     "start_time": "2025-10-31T14:23:02.741490300Z"
    }
   },
   "outputs": [],
   "source": [
    "# GRU\n",
    "def MyGRUTrain():\n",
    "    # 统计总的训练时间\n",
    "    global gru_total_time\n",
    "\n",
    "    # 实例化模型\n",
    "    my_gru = MyGRU(n_letters, n_hidden, categorys_num)\n",
    "\n",
    "    # 构建损失函数\n",
    "    mycrossentropyloss = nn.NLLLoss()\n",
    "\n",
    "    # 构建优化器\n",
    "    myadam = optim.Adam(my_gru.parameters(), lr=lr)\n",
    "\n",
    "    # 定义训练参数\n",
    "    total_iter_num = 0  # 迭代次数，已训练样本数\n",
    "    total_loss = 0.0  # 已训练的损失和\n",
    "    total_acc_num = 0  # 已训练样本准确总数\n",
    "\n",
    "    for epoch_idx in range(epochs):\n",
    "        start_time = time.time()  # 开始训练时间\n",
    "        for idx, (x, y) in tqdm(enumerate(name_class_dataload), total=len(name_class_dataload),\n",
    "                                desc=f'Epoch {epoch_idx + 1}/{epochs}'):\n",
    "            # 模型训练\n",
    "            output_n = my_gru(x)  # DataLoader会自动添加批次数\n",
    "            output = output_n[-1]\n",
    "\n",
    "            # 计算损失\n",
    "            myloss = mycrossentropyloss(output, y)\n",
    "\n",
    "            # 梯度清零\n",
    "            myadam.zero_grad()\n",
    "\n",
    "            # 反向传播\n",
    "            myloss.backward()\n",
    "\n",
    "            # 更新参数\n",
    "            myadam.step()\n",
    "\n",
    "            # 计算损失\n",
    "            total_iter_num += 1\n",
    "            total_loss += myloss\n",
    "\n",
    "            # 计算准确率\n",
    "            predit_tag = 1 if torch.argmax(output).item() == y.item() else 0\n",
    "            total_acc_num += predit_tag\n",
    "\n",
    "            # 每200批次求一次平均损失和平均准确率\n",
    "            if (idx + 1) % 200 == 0:\n",
    "                avg_loss = total_loss / total_iter_num\n",
    "                total_loss_list_gru.append(avg_loss.item())\n",
    "                avg_acc = total_acc_num / total_iter_num\n",
    "                total_acc_list_gru.append(avg_acc)\n",
    "\n",
    "        end_time = time.time()\n",
    "        epoch_time = end_time - start_time\n",
    "        gru_total_time += epoch_time\n",
    "        print(f'Epoch {epoch_idx + 1}/{epochs}, 损失:{avg_loss:.4f}, 准确率:{avg_acc:.4f}, 时间: {epoch_time:.2f}s')\n",
    "\n",
    "    # 保存模型\n",
    "    torch.save(my_gru.state_dict(), './model/my_gru_model.bin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 1/8: 100%|██████████| 20074/20074 [01:00<00:00, 332.37it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/8, 损失:0.9366, 准确率:0.7181, 时间: 60.40s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 2/8: 100%|██████████| 20074/20074 [01:04<00:00, 311.31it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2/8, 损失:0.7739, 准确率:0.7635, 时间: 64.48s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 3/8: 100%|██████████| 20074/20074 [01:06<00:00, 304.02it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3/8, 损失:0.6805, 准确率:0.7904, 时间: 66.03s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 4/8: 100%|██████████| 20074/20074 [01:06<00:00, 304.04it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4/8, 损失:0.6139, 准确率:0.8090, 时间: 66.03s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 5/8: 100%|██████████| 20074/20074 [01:12<00:00, 275.05it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5/8, 损失:0.5625, 准确率:0.8240, 时间: 72.99s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 6/8: 100%|██████████| 20074/20074 [01:07<00:00, 299.46it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6/8, 损失:0.5201, 准确率:0.8363, 时间: 67.04s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 7/8: 100%|██████████| 20074/20074 [01:04<00:00, 310.94it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7/8, 损失:0.4844, 准确率:0.8469, 时间: 64.56s\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Epoch 8/8: 100%|██████████| 20074/20074 [01:02<00:00, 323.11it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8/8, 损失:0.4537, 准确率:0.8563, 时间: 62.13s\n"
     ]
    }
   ],
   "source": [
    "MyGRUTrain()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.076570300Z",
     "start_time": "2025-10-31T14:23:02.744133300Z"
    }
   },
   "id": "4acc8a40e07f8d2f"
  },
  {
   "cell_type": "markdown",
   "id": "713d7881",
   "metadata": {},
   "source": [
    "## 5. 模型效果图"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "fa4ee157",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.232065700Z",
     "start_time": "2025-10-31T14:32:00.078949100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制损失对比曲线\n",
    "plt.figure(0)\n",
    "plt.plot(total_loss_list_rnn, label=\"RNN\")\n",
    "plt.plot(total_loss_list_lstm, label=\"LSTM\")\n",
    "plt.plot(total_loss_list_gru, label=\"GRU\")\n",
    "plt.legend(loc='upper right')\n",
    "plt.xlabel('Every 200 batches')\n",
    "plt.ylabel('Loss')\n",
    "plt.title('Loss of different models')\n",
    "plt.savefig('./img/Loss of different models.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "23867166",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.322415100Z",
     "start_time": "2025-10-31T14:32:00.234068100Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制训练时间柱状图\n",
    "plt.figure(1)\n",
    "x_data = [\"RNN\", \"LSTM\", \"GRU\"]\n",
    "y_data = [rnn_total_time, lstm_total_time, gru_total_time]\n",
    "# 绘制训练耗时对比柱状图\n",
    "bars = plt.bar(range(len(x_data)), y_data, tick_label=x_data)\n",
    "# 2. 循环添加标签\n",
    "for i, bar in enumerate(bars):\n",
    "    # 获取当前柱子的高度（y轴数值）\n",
    "    height = bar.get_height()\n",
    "    # 添加文本标签\n",
    "    plt.text(\n",
    "        i,  # x坐标（直接用柱子索引，因为x轴是range(len(x_data))）\n",
    "        height + 0.1,  # y坐标（柱子顶部 + 间距）\n",
    "        f'{height:.2f}',  # 标签内容\n",
    "        ha='center',  # 水平居中\n",
    "        va='bottom',  # 垂直在柱子顶部下方\n",
    "        fontsize=10\n",
    "    )\n",
    "plt.ylabel('Train Time(s)')\n",
    "plt.title('Training time of different models')\n",
    "plt.savefig('./img/Training time of different models.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "b1cc80e6",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.438833100Z",
     "start_time": "2025-10-31T14:32:00.317634Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 绘制准确率对比曲线\n",
    "plt.figure(2)\n",
    "plt.plot(total_acc_list_rnn, label=\"RNN\")\n",
    "plt.plot(total_acc_list_lstm, label=\"LSTM\")\n",
    "plt.plot(total_acc_list_gru, label=\"GRU\")\n",
    "plt.legend(loc='upper right')\n",
    "plt.title('Accuracy of different models')\n",
    "plt.xlabel('Every 200 batches')\n",
    "plt.ylabel('Accuracy')\n",
    "plt.savefig('./img/Accuracy of different models.png')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "91c93246",
   "metadata": {},
   "source": [
    "## 6. 预测函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "0456b0c8",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.438833100Z",
     "start_time": "2025-10-31T14:32:00.432712200Z"
    }
   },
   "outputs": [],
   "source": [
    "# 人名转换为张量\n",
    "def Name2Tensor(x):\n",
    "    tensor_x = torch.zeros(len(x), n_letters)\n",
    "    for idx, letter in enumerate(x):\n",
    "        tensor_x[idx][all_letters.find(letter)] = 1\n",
    "    return tensor_x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "outputs": [],
   "source": [
    "# 构建预测函数\n",
    "def Predict(x):\n",
    "    my_rnn = MyRnn(n_letters, n_hidden, categorys_num)\n",
    "    my_rnn.load_state_dict(torch.load('./model/my_rnn_model.bin'))\n",
    "\n",
    "    my_lstm = MyLSTM(n_letters, n_hidden, categorys_num)\n",
    "    my_lstm.load_state_dict(torch.load('./model/my_lstm_model.bin'))\n",
    "\n",
    "    my_gru = MyGRU(n_letters, n_hidden, categorys_num)\n",
    "    my_gru.load_state_dict(torch.load('./model/my_gru_model.bin'))\n",
    "\n",
    "    with torch.no_grad():\n",
    "        output_rnn = my_rnn(Name2Tensor(x))\n",
    "        _, topi = output_rnn.topk(3, -1, True)\n",
    "        print(f'{x}在RNN模型中预测前三的国家是：')\n",
    "        for i in range(3):\n",
    "            print(categorys[i])\n",
    "        print()\n",
    "\n",
    "        output_lstm = my_lstm(Name2Tensor(x))\n",
    "        _, topi = output_lstm.topk(3, -1, True)\n",
    "        print(f'{x}在LSTM模型中预测前三的国家是：')\n",
    "        for i in range(3):\n",
    "            print(categorys[i])\n",
    "        print()\n",
    "\n",
    "        output_gru = my_gru(Name2Tensor(x))\n",
    "        _, topi = output_gru.topk(3, -1, True)\n",
    "        print(f'{x}在LSTM模型中预测前三的国家是：')\n",
    "        for i in range(3):\n",
    "            print(categorys[i])\n",
    "        print()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.446151300Z",
     "start_time": "2025-10-31T14:32:00.437816600Z"
    }
   },
   "id": "48125aa0e771b13a"
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "James在RNN模型中预测前三的国家是：\n",
      "Italian\n",
      "English\n",
      "Arabic\n",
      "\n",
      "James在LSTM模型中预测前三的国家是：\n",
      "Italian\n",
      "English\n",
      "Arabic\n",
      "\n",
      "James在LSTM模型中预测前三的国家是：\n",
      "Italian\n",
      "English\n",
      "Arabic\n"
     ]
    }
   ],
   "source": [
    "# 测试代码\n",
    "name = 'James'\n",
    "Predict(name)"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2025-10-31T14:32:00.473991300Z",
     "start_time": "2025-10-31T14:32:00.443830700Z"
    }
   },
   "id": "83836497a21e7502"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
